package cn.it.xiaohan.note.service;

import cn.hutool.core.util.StrUtil;
import cn.it.xiaohan.note.dao.NoteDao;
import cn.it.xiaohan.note.po.Note;
import cn.it.xiaohan.note.util.Page;
import cn.it.xiaohan.note.vo.NoteVo;
import cn.it.xiaohan.note.vo.ResultInfo;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class NoteService {
    private NoteDao noteDao = new NoteDao();

    public ResultInfo<Note> addOrUpdate(String typeId, String title,
                                        String content,String noteId,
                                        String lon, String lat) {
        ResultInfo<Note> resultInfo = new ResultInfo<>();

        // 参数的非空判断
        if (StrUtil.isBlank(typeId)){
            resultInfo.setCode(0);
            resultInfo.setMsg("云记类型不能为空");
            return resultInfo;
        }
        if (StrUtil.isBlank(title)){
            resultInfo.setCode(0);
            resultInfo.setMsg("云记标题不能为空");
            return resultInfo;
        }
        if (StrUtil.isBlank(content)){
            resultInfo.setCode(0);
            resultInfo.setMsg("云记内容不能为空");
            return resultInfo;
        }

        // 设置默认经纬度 默认设置北京天安门：116.404, 39.915
        if (lon == null || lat == null){
            lon = "116.404";
            lat = "39.915";
        }

        // 设置回显
        Note note = new Note();
        note.setTypeId(Integer.parseInt(typeId));
        note.setTitle(title);
        note.setContent(content);
        note.setLon(Float.parseFloat(lon));
        note.setLat(Float.parseFloat(lat));

        // 判断云记ID 是否为空
        if (!StrUtil.isBlank(noteId)){
            note.setNoteId(Integer.parseInt(noteId));
        }
        resultInfo.setResult(note);

        // 程序执行到此处说明以上都不为空，调用dao层方法，返回受影响的行数
        int row = noteDao.addOrUpdate(typeId,title,content,noteId,lon,lat);

        if (row > 0){
            resultInfo.setCode(1);
        } else {
            resultInfo.setCode(0);
            resultInfo.setMsg("添加失败，请稍后重试");
            // resultInfo.setResult(note);
        }
        return resultInfo;
    }


    /**
     * 分页
     * @param pageNumStr
     * @param pageSizeStr
     * @param userId
     * @return
     */
    public Page<Note> findNoteListByPage(String pageNumStr, String pageSizeStr, Integer userId,
                                         String title, String date, String typeId) {
        Integer pageNum = 1; // 设置默认当前页为第一页
        Integer pageSize = 5; // 设置默认每页显示的数量为5条

        // 判断参数是否为空
        if (!StrUtil.isBlank(pageNumStr)){
            pageNum = Integer.parseInt(pageNumStr);
        }
        if (!StrUtil.isBlank(pageSizeStr)){
            pageSize = Integer.parseInt(pageSizeStr);
        }

        // 调用Dao层返回总的云记数量 （默认是long类型）
        long count = noteDao.findNoteCount(userId,title,date,typeId);

        // 判断云记数量是否大于0
        if (count < 1){
            return null;
        }

        // 4、如果大于0，调用Page类的带参构造，得到其他分页参数的值，返回Page对象
        Page<Note> page = new Page<>(pageNum,pageSize,count);

        // 得到数据库中分页查询的开始下标
        Integer index = (pageNum-1) * pageSize;

        // 查询当前登录用户下当前页的数据列表，返回note集合
        List<Note> noteList = noteDao.findNoteListByPage(userId,index,pageSize,title,date,typeId);

        // 将查询到的数据集合设置到page对象中
        page.setDataList(noteList);

        //返回page对象
        return page;
    }

    /**
     * 通过日期分组查询当前登录用户下的云记数量
     * @param userId
     * @return
     */
    public List<NoteVo> findNoteCountByDate(Integer userId) {
        return noteDao.findNoteCountByDate(userId);
    }

    /**
     * 通过日期分组查询当前登录用户下的云记数量
     * @param userId
     * @return
     */
    public List<NoteVo> findNoteCountByType(Integer userId) {
        return noteDao.findNoteCountByType(userId);
    }

    /**
     * 查询云记详情
     * @param noteId
     * @return
     */
    public Note findNoteById(String noteId) {
        // 参数的非空判断
        if(StrUtil.isBlank(noteId)){
            return null;
        }

        Note note = noteDao.findNoteById(noteId);

        return note;
    }

    /**
     * 删除云记
     * @param noteId
     * @return
     */
    public Integer deleteNote(String noteId) {
        // 参数的非空判断
        if (StrUtil.isBlank(noteId)){
            return 0;
        }

        // 调用Dao层方法返回受影响的行数
        int row = noteDao.deleteNote(noteId);

        // 判断受影响的行数
        if (row > 0){
            return 1;
        }
            return 0;
    }

    /**
     * 通过月份查询云记数量
     * @param userId
     * @return
     */
    public ResultInfo<Map<String, Object>> queryNoteCountByMonth(Integer userId) {
        ResultInfo<Map<String, Object>> resultInfo = new ResultInfo<>();

        // 通过月份分类查询云记数量
        List<NoteVo> noteVos = noteDao.findNoteCountByDate(userId);

        // 判断集合是否存在
        if (noteVos != null && noteVos.size() > 0){
            // 得到月份
            List<String> monthList = new ArrayList<>();
            // 得到云记数量
            List<Integer> noteCountList = new ArrayList<>();

            // 遍历月份分组集合
            for (NoteVo noteVo: noteVos) {
                monthList.add(noteVo.getGroupName());
                noteCountList.add((int)noteVo.getNoteCount());
            }

            // 准备Map对象，封装对应的月份与云记数量
            Map<String,Object> map = new HashMap<>();
            map.put("monthArray",monthList);
            map.put("dataArray",noteCountList);

            // 将map集合设置到ResultInfo中
            resultInfo.setCode(1);
            resultInfo.setResult(map);
        }
        return resultInfo;
    }

    /**
     * 通过用户发布的云记查询坐标
     * @param userId
     * @return
     */
    public ResultInfo<List<Note>> queryNoteLonAndLat(Integer userId) {
        ResultInfo<List<Note>> resultInfo = new ResultInfo<>();

        // 调用dao层的查询方法返回集合对象
        List<Note> noteList = noteDao.findNoteByLonAndLat(userId);

        // 判断集合是否为空
        if(noteList != null && noteList.size() > 0){
            resultInfo.setCode(1);
            resultInfo.setResult(noteList);
        }
        return resultInfo;
    }
}
